const express = require('express');
const fs = require('fs').promises;
const path = require('path');
const cors = require('cors');
const multer = require('multer');
const { MongoClient } = require('mongodb');
const crypto = require('crypto');

const app = express();
const PORT = process.env.PORT || 3000;
const DATA_FILE = path.join(__dirname, '..', 'js', 'data.json');

// MongoDB 配置
const MONGODB_URI = 'mongodb://localhost:27017';
const DB_NAME = 'TamiVocabularies';
const COLLECTIONS = {
  BASE_VOCABULARY: 'BaseVocabularyList', // 基础词库（只读）
  USERS: 'UserList' // 用户集合（包含个人单词库）
};

let db = null;
let client = null;

/**
 * MD5加密函数
 * @param {string} text - 要加密的文本
 * @returns {string} MD5加密后的字符串
 */
function md5(text) {
  return crypto.createHash('md5').update(text).digest('hex');
}

/**
 * 从MD5值生成一个可读的原始密码
 * 由于MD5不可逆，我们使用MD5值作为种子生成一个固定的密码
 * @param {string} md5Hash - MD5加密后的字符串
 * @returns {string} 生成的原始密码
 */
function generatePasswordFromMD5(md5Hash) {
  // 使用MD5的前16位作为种子
  const seed = md5Hash.substring(0, 16);
  
  // 定义字符集
  const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
  let password = '';
  
  // 使用种子生成8位密码
  for (let i = 0; i < 8; i++) {
    const charIndex = parseInt(seed.substring(i * 2, i * 2 + 2), 16) % chars.length;
    password += chars[charIndex];
  }
  
  return password;
}

/**
 * 存储MD5和原始密码的映射关系
 */
const passwordMap = new Map(); // 临时存储MD5到原始密码的映射

// 配置multer文件上传
const storage = multer.diskStorage({
  destination: async (req, file, cb) => {
    const uploadDir = path.join(__dirname, '..', 'img', 'users-avatar');
    try {
      await fs.access(uploadDir);
    } catch (error) {
      await fs.mkdir(uploadDir, { recursive: true });
    }
    cb(null, uploadDir);
  },
  filename: (req, file, cb) => {
    const { userId } = req.params;
    const timestamp = new Date().toISOString().replace(/[-:T]/g, '').split('.')[0];
    const ext = path.extname(file.originalname).toLowerCase();
    // 临时使用userId，在上传API中获取用户名并重命名
    const filename = `temp-${userId}-avatar-${timestamp}${ext}`;
    cb(null, filename);
  }
});

const fileFilter = (req, file, cb) => {
  const allowedTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp'];
  if (allowedTypes.includes(file.mimetype)) {
    cb(null, true);
  } else {
    cb(new Error('不支持的文件格式，仅允许 JPG, PNG, GIF, WEBP 格式'), false);
  }
};

const upload = multer({
  storage: storage,
  fileFilter: fileFilter,
  limits: {
    fileSize: 2 * 1024 * 1024 // 2MB限制
  }
});

// 中间件配置
app.use(cors());
app.use(express.json({ limit: '2mb' })); // 增加请求体大小限制以支持base64图片
app.use(express.urlencoded({ limit: '2mb', extended: true }));
app.use(express.static(path.join(__dirname, '..')));

/**
 * 连接到MongoDB数据库
 * @returns {Promise<boolean>} 返回连接是否成功
 */
const connectToDatabase = async () => {
  try {
    client = new MongoClient(MONGODB_URI);
    await client.connect();
    db = client.db(DB_NAME);
    console.log('✅ 成功连接到MongoDB数据库:', DB_NAME);
    return true;
  } catch (error) {
    console.error('❌ MongoDB连接失败:', error.message);
    return false;
  }
};

/**
 * 初始化数据库集合和数据
 * @returns {Promise<void>}
 */
const initializeDatabase = async () => {
  try {
    console.log('🔧 正在初始化数据库...');
    
    // 创建集合（如果不存在）
    const collections = await db.listCollections().toArray();
    const collectionNames = collections.map(col => col.name);
    
    // 创建基础词库集合（只读）
    if (!collectionNames.includes(COLLECTIONS.BASE_VOCABULARY)) {
      await db.createCollection(COLLECTIONS.BASE_VOCABULARY);
      console.log(`✅ 创建基础词库集合: ${COLLECTIONS.BASE_VOCABULARY}`);
      
      // 导入初始数据到基础词库
      const baseVocabularyCollection = db.collection(COLLECTIONS.BASE_VOCABULARY);
      const jsonData = await fs.readFile(DATA_FILE, 'utf8');
      const initialData = JSON.parse(jsonData);
      
      if (initialData && initialData.length > 0) {
        await baseVocabularyCollection.insertMany(initialData);
        console.log(`📚 导入 ${initialData.length} 个基础单词到 ${COLLECTIONS.BASE_VOCABULARY}`);
      }
      
      // 为基础词库创建索引
      await baseVocabularyCollection.createIndex({ word: 1 });
      await baseVocabularyCollection.createIndex({ createDate: -1 });
      console.log(`🔍 为 ${COLLECTIONS.BASE_VOCABULARY} 创建索引`);
    } else {
      console.log(`ℹ️  基础词库集合 ${COLLECTIONS.BASE_VOCABULARY} 已存在`);
    }
    
    // 创建用户集合
    if (!collectionNames.includes(COLLECTIONS.USERS)) {
      await db.createCollection(COLLECTIONS.USERS);
      console.log(`✅ 创建用户集合: ${COLLECTIONS.USERS}`);
      
      // 为用户集合创建索引
      const userCollection = db.collection(COLLECTIONS.USERS);
      await userCollection.createIndex({ account: 1 }, { unique: true });
      await userCollection.createIndex({ 'personalVocabulary.word': 1 });
      await userCollection.createIndex({ 'personalVocabulary.createDate': -1 });
      console.log(`🔍 为 ${COLLECTIONS.USERS} 创建索引`);
    } else {
      console.log(`ℹ️  用户集合 ${COLLECTIONS.USERS} 已存在`);
      
      // 为现有用户添加avatar字段（如果不存在）
      const userCollection = db.collection(COLLECTIONS.USERS);
      const usersWithoutAvatar = await userCollection.countDocuments({ avatar: { $exists: false } });
      
      if (usersWithoutAvatar > 0) {
        const result = await userCollection.updateMany(
          { avatar: { $exists: false } },
          { $set: { avatar: 'img/default-avatar.png' } }
        );
        console.log(`🔄 为 ${result.modifiedCount} 个用户添加默认头像字段`);
      }
    }
    
    console.log('✅ 数据库初始化完成');
    
  } catch (error) {
    console.error('❌ 数据库初始化失败:', error.message);
  }
};

/**
 * 读取数据文件
 * @returns {Promise<Array>} 返回单词数据数组
 */
const readDataFile = async () => {
  try {
    const data = await fs.readFile(DATA_FILE, 'utf8');
    return JSON.parse(data);
  } catch (error) {
    console.error('Error reading data file:', error);
    return [];
  }
};

/**
 * 写入数据文件
 * @param {Array} data - 要写入的数据数组
 * @returns {Promise<boolean>} 返回写入是否成功
 */
const writeDataFile = async (data) => {
  try {
    await fs.writeFile(DATA_FILE, JSON.stringify(data, null, 2), 'utf8');
    return true;
  } catch (error) {
    console.error('Error writing data file:', error);
    return false;
  }
};

/**
 * 生成新的单词ID
 * @param {Array} words - 现有单词数组
 * @returns {string} 返回新生成的单词ID
 */
const generateNewId = (words) => {
  if (words.length === 0) return 'word-00001';
  
  const maxId = words.reduce((max, word) => {
    const idNum = parseInt(word.id.split('-')[1]);
    return idNum > max ? idNum : max;
  }, 0);
  
  return `word-${String(maxId + 1).padStart(5, '0')}`;
};

// API 路由

// 获取用户个人单词库
app.get('/api/words', async (req, res) => {
  try {
    const { userId } = req.query;
    
    if (!userId) {
      return res.status(400).json({ error: '用户ID是必需的' });
    }
    
    if (!db) {
      console.error('❌ 数据库连接不可用');
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    // 验证ObjectId格式
    const { ObjectId } = require('mongodb');
    if (!ObjectId.isValid(userId)) {
      console.error('❌ 无效的用户ID格式:', userId);
      return res.status(400).json({ error: '无效的用户ID格式' });
    }
    
    console.log('🔍 查询用户单词库, userId:', userId);
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    const user = await userCollection.findOne(
      { _id: new ObjectId(userId) },
      { projection: { personalVocabulary: 1, vocabularyStats: 1 } }
    );
    
    if (!user) {
      console.error('❌ 用户不存在, userId:', userId);
      return res.status(404).json({ error: '用户不存在' });
    }
    
    // 返回用户的个人单词库，按创建时间倒序排列
    const personalVocabulary = user.personalVocabulary || [];
    const sortedWords = personalVocabulary.sort((a, b) => {
      const dateA = new Date(a.createDate);
      const dateB = new Date(b.createDate);
      return dateB - dateA;
    });
    
    console.log(`✅ 成功获取用户单词库: ${sortedWords.length} 个单词`);
    
    res.json({
      words: sortedWords,
      stats: user.vocabularyStats || { totalWords: sortedWords.length, memorizedWords: 0 }
    });
    
  } catch (error) {
    console.error('❌ 获取用户单词库失败:', {
      message: error.message,
      stack: error.stack,
      userId: req.query.userId
    });
    res.status(500).json({ error: '获取单词列表失败' });
  }
});

// 添加新单词到用户个人单词库
app.post('/api/words', async (req, res) => {
  try {
    const { userId, word, pronunciation, translation, example } = req.body;
    
    if (!userId) {
      return res.status(400).json({ error: '用户ID是必需的' });
    }
    
    if (!word || !translation) {
      return res.status(400).json({ error: '单词和翻译是必填字段' });
    }
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    const newWord = {
      id: Date.now().toString(),
      word: word.trim(),
      pronunciation: pronunciation ? pronunciation.trim() : '',
      translation: translation.trim(),
      example: example ? example.trim() : '',
      createDate: new Date(), // 使用标准DateTime格式
      memorized: false
    };
    
    // 验证ObjectId格式
    const { ObjectId } = require('mongodb');
    if (!ObjectId.isValid(userId)) {
      console.error('❌ 无效的用户ID格式:', userId);
      return res.status(400).json({ error: '无效的用户ID格式' });
    }
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    
    // 检查用户是否已存在该单词
    const existingUser = await userCollection.findOne({
      _id: new ObjectId(userId),
      'personalVocabulary.word': word.trim()
    });
    
    if (existingUser) {
      return res.status(409).json({ error: '该单词已存在于您的个人单词库中' });
    }
    
    // 添加单词到用户的个人单词库
    const result = await userCollection.updateOne(
      { _id: new ObjectId(userId) },
      {
        $push: { personalVocabulary: newWord },
        $inc: { 'vocabularyStats.totalWords': 1 },
        $set: { 'vocabularyStats.lastUpdated': new Date().toISOString() }
      }
    );
    
    if (result.matchedCount === 0) {
      return res.status(404).json({ error: '用户不存在' });
    }
    
    console.log(`✅ 用户 ${userId} 添加新单词: ${word}`);
    res.status(201).json(newWord);
    
  } catch (error) {
    console.error('❌ 添加单词失败:', error.message);
    res.status(500).json({ error: '添加单词失败' });
  }
});

// 更新用户个人单词库中的单词
app.put('/api/words/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const { userId, word, pronunciation, translation, example } = req.body;
    
    if (!userId) {
      return res.status(400).json({ error: '用户ID是必需的' });
    }
    
    if (!word || !translation) {
      return res.status(400).json({ error: '单词和翻译是必填字段' });
    }
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    // 验证ObjectId格式
    const { ObjectId } = require('mongodb');
    if (!ObjectId.isValid(userId)) {
      console.error('❌ 无效的用户ID格式:', userId);
      return res.status(400).json({ error: '无效的用户ID格式' });
    }
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    
    // 更新用户个人单词库中的指定单词
    const result = await userCollection.updateOne(
      { 
        _id: new ObjectId(userId),
        'personalVocabulary.id': id
      },
      {
        $set: {
          'personalVocabulary.$.word': word.trim(),
          'personalVocabulary.$.pronunciation': pronunciation ? pronunciation.trim() : '',
          'personalVocabulary.$.translation': translation.trim(),
          'personalVocabulary.$.example': example ? example.trim() : '',
          'vocabularyStats.lastUpdated': new Date().toISOString()
        }
      }
    );
    
    if (result.matchedCount === 0) {
      return res.status(404).json({ error: '单词不存在或用户无权限' });
    }
    
    if (result.modifiedCount === 0) {
      return res.status(400).json({ error: '没有内容被修改' });
    }
    
    // 返回更新后的单词信息
    const updatedWord = {
      id,
      word: word.trim(),
      pronunciation: pronunciation ? pronunciation.trim() : '',
      translation: translation.trim(),
      example: example ? example.trim() : ''
    };
    
    console.log(`✅ 用户 ${userId} 更新单词: ${word}`);
    res.json(updatedWord);
    
  } catch (error) {
    console.error('❌ 更新单词失败:', error.message);
    res.status(500).json({ error: '更新单词失败' });
  }
});

// 从用户个人单词库中删除单词
app.delete('/api/words/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const { userId } = req.query;
    
    if (!userId) {
      return res.status(400).json({ error: '用户ID是必需的' });
    }
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    // 验证ObjectId格式
    const { ObjectId } = require('mongodb');
    if (!ObjectId.isValid(userId)) {
      console.error('❌ 无效的用户ID格式:', userId);
      return res.status(400).json({ error: '无效的用户ID格式' });
    }
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    
    // 获取要删除的单词信息（用于统计更新）
    const user = await userCollection.findOne(
      { _id: new ObjectId(userId) },
      { projection: { personalVocabulary: { $elemMatch: { id: id } } } }
    );
    
    if (!user || !user.personalVocabulary || user.personalVocabulary.length === 0) {
      return res.status(404).json({ error: '单词不存在' });
    }
    
    const wordToDelete = user.personalVocabulary[0];
    const wasMemorized = wordToDelete.memorized;
    
    // 从用户个人单词库中删除指定单词
    const result = await userCollection.updateOne(
      { _id: new ObjectId(userId) },
      {
        $pull: { personalVocabulary: { id: id } },
        $inc: {
          'vocabularyStats.totalWords': -1,
          ...(wasMemorized && { 'vocabularyStats.memorizedWords': -1 })
        },
        $set: { 'vocabularyStats.lastUpdated': new Date().toISOString() }
      }
    );
    
    if (result.matchedCount === 0) {
      return res.status(404).json({ error: '用户不存在' });
    }
    
    if (result.modifiedCount === 0) {
      return res.status(400).json({ error: '删除操作失败' });
    }
    
    console.log(`✅ 用户 ${userId} 删除单词: ${wordToDelete.word}`);
    res.json({ message: '单词删除成功', deletedWord: wordToDelete });
    
  } catch (error) {
    console.error('❌ 删除单词失败:', error.message);
    res.status(500).json({ error: '删除单词失败' });
  }
});

// 切换用户个人单词库中单词的记忆状态
app.patch('/api/words/:id/memorized', async (req, res) => {
  try {
    const { id } = req.params;
    const { userId } = req.body;
    
    if (!userId) {
      return res.status(400).json({ error: '用户ID是必需的' });
    }
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    // 验证ObjectId格式
    const { ObjectId } = require('mongodb');
    if (!ObjectId.isValid(userId)) {
      console.error('❌ 无效的用户ID格式:', userId);
      return res.status(400).json({ error: '无效的用户ID格式' });
    }
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    
    // 获取当前单词的记忆状态
    const user = await userCollection.findOne(
      { _id: new ObjectId(userId) },
      { projection: { personalVocabulary: { $elemMatch: { id: id } } } }
    );
    
    if (!user || !user.personalVocabulary || user.personalVocabulary.length === 0) {
      return res.status(404).json({ error: '单词不存在' });
    }
    
    const currentWord = user.personalVocabulary[0];
    const newMemorizedStatus = !currentWord.memorized;
    
    // 更新单词的记忆状态
    const result = await userCollection.updateOne(
      { 
        _id: new ObjectId(userId),
        'personalVocabulary.id': id
      },
      {
        $set: {
          'personalVocabulary.$.memorized': newMemorizedStatus,
          'vocabularyStats.lastUpdated': new Date().toISOString()
        },
        $inc: {
          'vocabularyStats.memorizedWords': newMemorizedStatus ? 1 : -1
        }
      }
    );
    
    if (result.matchedCount === 0) {
      return res.status(404).json({ error: '单词不存在或用户无权限' });
    }
    
    // 返回更新后的单词信息
    const updatedWord = {
      ...currentWord,
      memorized: newMemorizedStatus
    };
    
    console.log(`✅ 用户 ${userId} 切换单词记忆状态: ${currentWord.word} -> ${newMemorizedStatus ? '已记住' : '未记住'}`);
    res.json(updatedWord);
    
  } catch (error) {
    console.error('❌ 更新单词记忆状态失败:', error.message);
    res.status(500).json({ error: '更新单词状态失败' });
  }
});

// 搜索单词
app.get('/api/words/search', async (req, res) => {
  try {
    const words = await readDataFile();
    const { q } = req.query;
    
    if (!q) {
      return res.json(words);
    }
    
    const lowerQuery = q.toLowerCase();
    const filteredWords = words.filter(word => 
      word.word.toLowerCase().includes(lowerQuery) || 
      word.translation.toLowerCase().includes(lowerQuery)
    );
    
    res.json(filteredWords);
  } catch (error) {
    res.status(500).json({ error: 'Failed to search words' });
  }
});

// 用户注册API
app.post('/api/users/register', async (req, res) => {
  try {
    const { account, nickname, password } = req.body;
    
    if (!account || !nickname || !password) {
      return res.status(400).json({ error: '所有字段都是必填的' });
    }
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    
    // 检查用户是否已存在
    const existingUser = await userCollection.findOne({ account });
    if (existingUser) {
      return res.status(409).json({ error: '该账号已被注册' });
    }
    
    // 处理MD5加密的密码
    // 前端发送的是MD5加密后的密码，我们需要生成一个原始密码来存储
    // 由于MD5不可逆，我们使用一种特殊的方法：将MD5值作为种子生成一个可读的密码
    const originalPassword = generatePasswordFromMD5(password);
    
    console.log(`🔐 注册密码处理: MD5=${password.substring(0, 8)}..., 生成原始密码用于存储`);
    
    // 从基础词库复制数据到用户个人词库
    const baseVocabularyCollection = db.collection(COLLECTIONS.BASE_VOCABULARY);
    const baseWords = await baseVocabularyCollection.find({}).toArray();
    
    // 为每个基础单词生成新的ID，重置记忆状态，保留原始创建时间
    const personalVocabulary = baseWords.map(word => ({
      ...word,
      id: Date.now().toString() + Math.random().toString(36).substr(2, 9), // 生成新的唯一ID
      memorized: false // 重置记忆状态，保留原始createDate
    }));
    
    console.log(`📚 为新用户复制 ${personalVocabulary.length} 个基础单词`);
    
    // 存储MD5和原始密码的映射关系
    passwordMap.set(password, originalPassword);
    
    // 创建新用户（包含个人单词库）
    const newUser = {
      account,
      nickname,
      password: originalPassword, // 存储生成的原始密码
      md5Password: password, // 同时存储MD5密码用于验证
      createDate: new Date().toISOString(),
      lastLoginDate: null,
      personalVocabulary, // 复制的基础词库数据
      vocabularyStats: {
        totalWords: personalVocabulary.length,
        memorizedWords: 0,
        lastUpdated: new Date().toISOString()
      }
    };
    
    const result = await userCollection.insertOne(newUser);
    
    console.log(`✅ 新用户注册成功: ${nickname} (${account})`);
    
    res.status(201).json({
      success: true,
      message: '注册成功',
      user: {
        id: result.insertedId,
        account,
        nickname,
        createDate: newUser.createDate
      }
    });
    
  } catch (error) {
    console.error('❌ 用户注册失败:', error.message);
    res.status(500).json({ error: '注册失败，请重试' });
  }
});

// 用户登录API
app.post('/api/users/login', async (req, res) => {
  try {
    const { account, password } = req.body;
    
    if (!account || !password) {
      return res.status(400).json({ error: '账号和密码都是必填的' });
    }
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    
    // 查找用户
    const user = await userCollection.findOne({ account });
    if (!user) {
      return res.status(401).json({ error: '账号或密码错误' });
    }
    
    // 验证密码
    // 前端发送的是MD5加密后的密码，需要与数据库中存储的MD5密码比较
    let isPasswordValid = false;
    
    if (user.md5Password) {
      // 新用户：直接比较MD5密码
      isPasswordValid = user.md5Password === password;
      console.log(`🔐 登录密码验证: 使用MD5比较 ${password.substring(0, 8)}... === ${user.md5Password.substring(0, 8)}...`);
    } else {
      // 旧用户：需要将原始密码转换为MD5后比较
      const userPasswordMD5 = md5(user.password);
      isPasswordValid = userPasswordMD5 === password;
      console.log(`🔐 登录密码验证: 旧用户密码MD5转换后比较`);
    }
    
    if (!isPasswordValid) {
      return res.status(401).json({ error: '账号或密码错误' });
    }
    
    // 更新最后登录时间
    await userCollection.updateOne(
      { _id: user._id },
      { $set: { lastLoginDate: new Date().toISOString() } }
    );
    
    console.log(`✅ 用户登录成功: ${user.nickname} (${account})`);
    
    res.json({
      success: true,
      message: '登录成功',
      user: {
        id: user._id,
        account: user.account,
        nickname: user.nickname,
        avatar: user.avatar || 'img/default-avatar.png',
        gender: user.gender,
        phone: user.phone,
        email: user.email,
        bio: user.bio,
        createDate: user.createDate,
        lastLoginDate: new Date().toISOString()
      }
    });
    
  } catch (error) {
    console.error('❌ 用户登录失败:', error.message);
    res.status(500).json({ error: '登录失败，请重试' });
  }
});

// 获取基础词库（只读，供未登录用户使用）
app.get('/api/base-vocabulary', async (req, res) => {
  try {
    const { page = 1, limit = 50, search = '' } = req.query;
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    const baseVocabularyCollection = db.collection(COLLECTIONS.BASE_VOCABULARY);
    
    // 构建查询条件
    const query = search ? {
      $or: [
        { word: { $regex: search, $options: 'i' } },
        { translation: { $regex: search, $options: 'i' } }
      ]
    } : {};
    
    // 计算分页
    const skip = (parseInt(page) - 1) * parseInt(limit);
    
    // 获取总数和分页数据
    const [totalCount, words] = await Promise.all([
      baseVocabularyCollection.countDocuments(query),
      baseVocabularyCollection
        .find(query)
        .sort({ createDate: -1 })
        .skip(skip)
        .limit(parseInt(limit))
        .toArray()
    ]);
    
    console.log(`📖 返回基础词库数据: ${words.length} 个单词`);
    
    res.json({
      words,
      pagination: {
        currentPage: parseInt(page),
        totalPages: Math.ceil(totalCount / parseInt(limit)),
        totalCount,
        limit: parseInt(limit)
      }
    });
    
  } catch (error) {
    console.error('❌ 获取基础词库失败:', error.message);
    res.status(500).json({ error: '获取基础词库失败' });
  }
});

// 初始化用户个人词库（从基础词库复制数据）
app.post('/api/users/initialize-vocabulary', async (req, res) => {
  try {
    const { userId } = req.body;
    
    if (!userId) {
      return res.status(400).json({ error: '用户ID是必需的' });
    }
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    // 验证ObjectId格式
    const { ObjectId } = require('mongodb');
    if (!ObjectId.isValid(userId)) {
      return res.status(400).json({ error: '无效的用户ID格式' });
    }
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    
    // 检查用户是否存在
    const user = await userCollection.findOne(
      { _id: new ObjectId(userId) },
      { projection: { personalVocabulary: 1 } }
    );
    
    if (!user) {
      return res.status(404).json({ error: '用户不存在' });
    }
    
    // 如果用户已有词汇数据，不重复初始化
    if (user.personalVocabulary && user.personalVocabulary.length > 0) {
      return res.status(409).json({ 
        error: '用户词库已存在数据',
        currentCount: user.personalVocabulary.length
      });
    }
    
    // 从基础词库复制数据
    const baseVocabularyCollection = db.collection(COLLECTIONS.BASE_VOCABULARY);
    const baseWords = await baseVocabularyCollection.find({}).toArray();
    
    // 为每个基础单词生成新的ID，重置记忆状态，保留原始创建时间
    const personalVocabulary = baseWords.map(word => ({
      ...word,
      id: Date.now().toString() + Math.random().toString(36).substr(2, 9),
      memorized: false // 保留原始createDate
    }));
    
    // 更新用户的个人词库
    const result = await userCollection.updateOne(
      { _id: new ObjectId(userId) },
      {
        $set: {
          personalVocabulary,
          vocabularyStats: {
            totalWords: personalVocabulary.length,
            memorizedWords: 0,
            lastUpdated: new Date().toISOString()
          }
        }
      }
    );
    
    if (result.matchedCount === 0) {
      return res.status(404).json({ error: '用户不存在' });
    }
    
    console.log(`✅ 用户 ${userId} 初始化词库: ${personalVocabulary.length} 个单词`);
    
    res.json({
      success: true,
      message: '词库初始化成功',
      totalWords: personalVocabulary.length
    });
    
  } catch (error) {
    console.error('❌ 初始化用户词库失败:', error.message);
    res.status(500).json({ error: '初始化词库失败' });
  }
});

// 更新用户信息
app.put('/api/users/:userId', async (req, res) => {
  try {
    const { userId } = req.params;
    const { nickname, gender, phone, email, bio, avatar } = req.body;
    
    if (!userId) {
      return res.status(400).json({ error: '用户ID是必需的' });
    }
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    // 验证ObjectId格式
    const { ObjectId } = require('mongodb');
    if (!ObjectId.isValid(userId)) {
      console.error('❌ 无效的用户ID格式:', userId);
      return res.status(400).json({ error: '无效的用户ID格式' });
    }
    
    // 验证头像数据大小
    if (avatar && avatar.length > 1024 * 1024) { // 1MB限制
      console.error('❌ 头像数据过大:', avatar.length);
      return res.status(413).json({ error: '头像文件过大，请选择较小的图片' });
    }
    
    console.log(`🔄 更新用户信息, userId: ${userId}, 包含字段:`, Object.keys(req.body));
    if (avatar) {
      console.log(`📷 头像数据大小: ${Math.round(avatar.length / 1024)}KB`);
    }
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    
    // 构建更新数据
    const updateData = {
      lastUpdated: new Date().toISOString()
    };
    
    if (nickname !== undefined) updateData.nickname = nickname;
    if (gender !== undefined) updateData.gender = gender;
    if (phone !== undefined) updateData.phone = phone;
    if (email !== undefined) updateData.email = email;
    if (bio !== undefined) updateData.bio = bio;
    if (avatar !== undefined) updateData.avatar = avatar;
    
    console.log(`💾 准备更新字段:`, Object.keys(updateData));
    
    // 更新用户信息
    const result = await userCollection.updateOne(
      { _id: new ObjectId(userId) },
      { $set: updateData }
    );
    
    console.log(`📊 数据库操作结果:`, {
      matchedCount: result.matchedCount,
      modifiedCount: result.modifiedCount,
      acknowledged: result.acknowledged
    });
    
    if (result.matchedCount === 0) {
      return res.status(404).json({ error: '用户不存在' });
    }
    
    if (result.modifiedCount === 0) {
      return res.status(200).json({ 
        success: true, 
        message: '用户信息无变化',
        modified: false
      });
    }
    
    // 获取更新后的用户信息
    const updatedUser = await userCollection.findOne(
      { _id: new ObjectId(userId) },
      { projection: { password: 0 } } // 不返回密码
    );
    
    console.log(`✅ 用户信息更新成功: ${userId}`);
    
    res.json({
      success: true,
      message: '用户信息更新成功',
      user: updatedUser,
      modified: true
    });
    
  } catch (error) {
    console.error('❌ 更新用户信息失败:', {
      message: error.message,
      stack: error.stack,
      userId: req.params.userId
    });
    
    // 根据错误类型返回不同的状态码
    if (error.name === 'MongoError' || error.name === 'MongoServerError') {
      return res.status(500).json({ error: '操作失败，请稍后重试' });
    }
    
    res.status(500).json({ error: '更新用户信息失败' });
  }
});

// 头像上传接口
app.post('/api/users/:userId/avatar', upload.single('avatar'), async (req, res) => {
  try {
    const { userId } = req.params;
    
    if (!userId) {
      return res.status(400).json({ error: '用户ID是必需的' });
    }
    
    if (!req.file) {
      return res.status(400).json({ error: '请选择要上传的头像文件' });
    }
    
    if (!db) {
      return res.status(500).json({ error: '系统暂时不可用，请稍后重试' });
    }
    
    // 验证ObjectId格式
    const { ObjectId } = require('mongodb');
    if (!ObjectId.isValid(userId)) {
      console.error('❌ 无效的用户ID格式:', userId);
      return res.status(400).json({ error: '无效的用户ID格式' });
    }
    
    console.log(`📷 用户 ${userId} 上传头像:`, req.file.filename);
    
    const userCollection = db.collection(COLLECTIONS.USERS);
    
    // 获取用户当前信息
    const currentUser = await userCollection.findOne(
      { _id: new ObjectId(userId) },
      { projection: { avatar: 1, account: 1 } }
    );
    
    if (!currentUser) {
      // 删除刚上传的文件
      await fs.unlink(req.file.path).catch(console.error);
      return res.status(404).json({ error: '用户不存在' });
    }
    
    // 删除该用户的所有历史头像文件
    try {
      const uploadDir = path.join(__dirname, '..', 'img', 'users-avatar');
      const files = await fs.readdir(uploadDir);
      
      // 处理用户名用于匹配历史文件
      let usernameForPattern = currentUser.account;
      if (usernameForPattern.includes('@')) {
        usernameForPattern = usernameForPattern.split('@')[0];
      }
      usernameForPattern = usernameForPattern.replace(/[<>:"/\\|?*]/g, '_');
      
      // 查找该用户的所有头像文件（格式：处理后用户名-avatar-时间戳.扩展名）
      const userAvatarPattern = new RegExp(`^${usernameForPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-avatar-\\d+\\.(jpg|jpeg|png|gif|webp)$`, 'i');
      const userAvatarFiles = files.filter(file => userAvatarPattern.test(file));
      
      console.log(`🔍 查找用户 ${currentUser.account} 的历史头像文件，匹配模式: ${usernameForPattern}-avatar-*`);
      
      // 删除所有匹配的历史头像文件
      for (const file of userAvatarFiles) {
        const filePath = path.join(uploadDir, file);
        try {
          await fs.unlink(filePath);
          console.log(`🗑️ 删除历史头像: ${file}`);
        } catch (error) {
          console.warn(`⚠️ 删除历史头像失败 ${file}:`, error.message);
        }
      }
      
      if (userAvatarFiles.length > 0) {
        console.log(`✅ 成功清理 ${userAvatarFiles.length} 个历史头像文件`);
      }
    } catch (error) {
      console.warn('⚠️ 清理历史头像文件失败:', error.message);
    }
    
    // 重命名临时文件为正确的格式
    const tempFilePath = req.file.path;
    const timestamp = new Date().toISOString().replace(/[-:T]/g, '').split('.')[0];
    const ext = path.extname(req.file.originalname).toLowerCase();
    
    // 处理用户名：如果是邮箱格式，提取@符号前的部分
    let username = currentUser.account;
    if (username.includes('@')) {
      username = username.split('@')[0];
      console.log(`📧 检测到邮箱账号，提取用户名: ${currentUser.account} → ${username}`);
    }
    
    // 进一步清理用户名，移除可能导致文件系统问题的特殊字符
    username = username.replace(/[<>:"/\\|?*]/g, '_');
    
    const newFileName = `${username}-avatar-${timestamp}${ext}`;
    const newFilePath = path.join(path.dirname(tempFilePath), newFileName);
    
    try {
      await fs.rename(tempFilePath, newFilePath);
      console.log(`📝 文件重命名: ${req.file.filename} → ${newFileName}`);
    } catch (error) {
      console.error('❌ 文件重命名失败:', error.message);
      // 如果重命名失败，删除临时文件
      await fs.unlink(tempFilePath).catch(console.error);
      return res.status(500).json({ error: '文件处理失败' });
    }
    
    // 构建新的头像路径
    const avatarPath = `img/users-avatar/${newFileName}`;
    
    // 更新数据库中的头像路径
    const result = await userCollection.updateOne(
      { _id: new ObjectId(userId) },
      { 
        $set: { 
          avatar: avatarPath,
          lastUpdated: new Date().toISOString()
        }
      }
    );
    
    if (result.modifiedCount === 0) {
      console.warn('⚠️ 数据库更新失败');
      return res.status(500).json({ error: '头像路径更新失败' });
    }
    
    // 获取更新后的用户信息
    const updatedUser = await userCollection.findOne(
      { _id: new ObjectId(userId) },
      { projection: { password: 0 } }
    );
    
    console.log(`✅ 头像上传成功: ${avatarPath}`);
    
    res.json({
      success: true,
      message: '头像上传成功',
      avatarPath: avatarPath,
      user: updatedUser
    });
    
  } catch (error) {
    console.error('❌ 头像上传失败:', {
      message: error.message,
      stack: error.stack,
      userId: req.params.userId
    });
    
    // 删除上传的文件（如果存在）
    if (req.file) {
      await fs.unlink(req.file.path).catch(console.error);
    }
    
    if (error.code === 'LIMIT_FILE_SIZE') {
      return res.status(413).json({ error: '文件大小超过2MB限制' });
    }
    
    if (error.message.includes('不支持的文件格式')) {
      return res.status(400).json({ error: error.message });
    }
    
    res.status(500).json({ error: '头像上传失败' });
  }
});

// 错误处理中间件
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something went wrong!' });
});

// 404 处理
app.use((req, res) => {
  res.status(404).json({ error: 'Route not found' });
});

// 启动服务器
app.listen(PORT, async () => {
  console.log(`🚀 English Vocabulary Book 服务器已启动: http://localhost:${PORT}`);
  console.log(`📚 数据文件路径: ${DATA_FILE}`);
  console.log(`🔄 开发模式启动命令: nodemon server/english-vocabulary-book.js`);
  
  // 连接数据库并初始化
  const connected = await connectToDatabase();
  if (connected) {
    await initializeDatabase();
    console.log('🎉 数据库连接和初始化完成');
  } else {
    console.log('⚠️  数据库连接失败，将使用文件存储模式');
  }
});

// 优雅关闭
process.on('SIGTERM', async () => {
  console.log('\n👋 服务器正在优雅关闭...');
  if (client) {
    await client.close();
    console.log('✅ MongoDB连接已关闭');
  }
  process.exit(0);
});

process.on('SIGINT', async () => {
  console.log('\n👋 服务器正在优雅关闭...');
  if (client) {
    await client.close();
    console.log('✅ MongoDB连接已关闭');
  }
  process.exit(0);
});

module.exports = app;